home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / utils / xad / developer / sources / clients / xmash.c < prev    next >
C/C++ Source or Header  |  1999-01-01  |  5KB  |  225 lines
  1. #ifndef XADMASTER_XMASH_C
  2. #define XADMASTER_XMASH_C
  3.  
  4. /* Programmheader
  5.  
  6.     Name:        xMash.c
  7.     Main:        xadmaster
  8.     Versionstring:    $VER: xMash.c 1.1 (04.02.1999)
  9.     Author:        SDI
  10.     Distribution:    Freeware
  11.     Description:    xMash disk archiver client
  12.  
  13.  1.0   05.09.98 : first version
  14.  1.1   04.02.99 : added new InfoText system
  15. */
  16.  
  17. #include <proto/xadmaster.h>
  18. #include "SDI_compiler.h"
  19. #include "xpkstuff.c"
  20.  
  21. #ifndef XADMASTERFILE
  22. #define xMash_Client        FirstClient
  23. #define NEXTCLIENT        0
  24. UBYTE version[] = "$VER: xMash 1.1 (04.02.1999)";
  25. #endif
  26. #define XMASH_VERSION        1
  27. #define XMASH_REVISION        1
  28.  
  29. /*
  30.   structure of one xMash chunk:
  31.     UBYTE        xmc_Type;
  32.     UBYTE        xmc_Start
  33.     UBYTE        xmc_Num;
  34.     ULONG        xmc_Size;
  35. */
  36.  
  37. #define XMASH_INFOTEXT    0x46
  38. #define XMASH_BANNER    0x42
  39. #define XMASH_ARCHIVE    0x44
  40.  
  41. struct xMashHead {
  42.   UBYTE    type;
  43.   UBYTE start;
  44.   UBYTE num;
  45. };
  46.  
  47. ASM(BOOL) xMash_RecogData(REG(d0, ULONG size), REG(a0, STRPTR data),
  48. REG(a6, struct xadMasterBase *xadMasterBase))
  49. {
  50.   if(data[0] == 'M' && data[1] == 'S' && data[2] == 'H' &&
  51.   (data[3] == XMASH_BANNER || data[3] == XMASH_ARCHIVE || data[3] ==
  52.   XMASH_INFOTEXT))
  53.     return 1;
  54.   else
  55.     return 0;
  56. }
  57.  
  58. ASM(LONG) xMash_GetInfo(REG(a0, struct xadArchiveInfo *ai),
  59. REG(a6, struct xadMasterBase *xadMasterBase))
  60. {
  61.   LONG err, lowcyl = 80, highcyl = -1;
  62.   ULONG dat[9], start = 3;
  63.   struct xadDiskInfo *xdi;
  64.   struct xadTextInfo *ti = 0;
  65.   struct xMashHead h;
  66.  
  67.   if(!(xdi = (struct xadDiskInfo *) xadAllocObjectA(XADOBJ_DISKINFO, 0)))
  68.     return XADERR_NOMEMORY;
  69.   ai->xai_DiskInfo = xdi;
  70.  
  71.   xdi->xdi_EntryNumber = 1;
  72.   xdi->xdi_SectorSize = 512;
  73.   xdi->xdi_Cylinders = 80;
  74.   xdi->xdi_Heads = 2;
  75.   xdi->xdi_TrackSectors = 11;
  76.   xdi->xdi_CylSectors = 22;
  77.   xdi->xdi_TotalSectors = 80 * 22;
  78.  
  79.   if((err = xadHookAccess(XADAC_INPUTSEEK, 3, 0, ai))) /* skip MSH */
  80.     return err;
  81.  
  82.   while(ai->xai_InPos < ai->xai_InSize && !err)
  83.   {
  84.     if(!(err = xadHookAccess(XADAC_READ, 3, &h, ai)) &&
  85.     !(err = xadHookAccess(XADAC_READ, 4, dat, ai)))
  86.     {
  87.       switch(h.type)
  88.       {
  89.       case XMASH_INFOTEXT: case XMASH_BANNER:
  90.         {
  91.           struct xadTextInfo *ti2;
  92.           if((ti2 = (struct xadTextInfo *) xadAllocObjectA(XADOBJ_TEXTINFO, 0)))
  93.           {
  94.         if(h.type == XMASH_BANNER)
  95.               ti2->xti_Flags |= XADTIF_BANNER;
  96.  
  97.             err = xpkDecrunch(&ti2->xti_Text, &ti2->xti_Size, ai, xadMasterBase);
  98.  
  99.             start = ai->xai_InPos;
  100.  
  101.             if(!ti)
  102.               xdi->xdi_TextInfo = ti2;
  103.             else
  104.               ti->xti_Next = ti2;
  105.             ti = ti2;
  106.           }
  107.           else
  108.             err = XADERR_NOMEMORY;
  109.         break;
  110.         }
  111.       case XMASH_ARCHIVE:
  112.         if(!(err = xadHookAccess(XADAC_READ, 36, dat, ai)) &&
  113.         !(err = xadHookAccess(XADAC_INPUTSEEK, dat[1]-28, 0, ai)))
  114.         {
  115.           if(dat[8] & (1<<25))
  116.           { /* check for password flag in every entry */
  117.             ai->xai_Flags |= XADAIF_CRYPTED;
  118.             xdi->xdi_Flags |= XADDIF_CRYPTED;
  119.           }
  120.           h.num = ((h.num+h.start) >> 1)-1;
  121.           h.start >>= 1;
  122.           if(h.start < lowcyl)
  123.             lowcyl = h.start;
  124.           if(h.num > highcyl)
  125.             highcyl = h.num;
  126.         }
  127.         break;
  128.       }
  129.     }
  130.   }
  131.  
  132.   if(lowcyl <= highcyl)
  133.   {
  134.     xdi->xdi_LowCyl  = lowcyl;
  135.     xdi->xdi_HighCyl = highcyl;
  136.   }
  137.   else
  138.     err = XADERR_INPUT;
  139.  
  140.   if(!err)
  141.     err = xadHookAccess(XADAC_INPUTSEEK, start-ai->xai_InPos, 0, ai);
  142.  
  143.   return err;
  144. }
  145.  
  146. ASM(LONG) xMash_UnArchive(REG(a0, struct xadArchiveInfo *ai),
  147. REG(a6, struct xadMasterBase *xadMasterBase))
  148. {
  149.   struct xMashHead h;
  150.   LONG err = 0, u;
  151.   ULONG size, lowcyl;
  152.   STRPTR a;
  153.   struct ExecBase * SysBase = xadMasterBase->xmb_SysBase;
  154.  
  155.   u = ai->xai_InPos;
  156.   lowcyl = ai->xai_LowCyl;
  157.  
  158.   while(!err && lowcyl <= ai->xai_HighCyl)
  159.   {
  160.     if(!(err = xadHookAccess(XADAC_READ, 3, &h, ai)) &&
  161.     !(err = xadHookAccess(XADAC_READ, 4, &size, ai)))
  162.     {
  163.       LONG endcyl, startcyl, skipbyte;
  164.  
  165.       startcyl = h.start>>1;
  166.       endcyl = ((h.start+h.num)>>1)-1;
  167.  
  168.       if(endcyl < lowcyl)
  169.         err = xadHookAccess(XADAC_INPUTSEEK, size, 0, ai);
  170.       else
  171.       {
  172.     ULONG size;
  173.         if(!(err = xpkDecrunch(&a, &size, ai, xadMasterBase)))
  174.         {
  175.       skipbyte = 0;
  176.  
  177.           if(startcyl < lowcyl)
  178.             skipbyte = (lowcyl-startcyl)*22*512;
  179.           if(endcyl > ai->xai_HighCyl)
  180.             endcyl = ai->xai_HighCyl;
  181.       size = (endcyl+1-lowcyl)*22*512;
  182.             
  183.           err = xadHookAccess(XADAC_WRITE, size, a+skipbyte, ai);
  184.           FreeVec(a);
  185.           lowcyl = endcyl+1;
  186.         }
  187.       }
  188.     }
  189.   }
  190.  
  191.   /* seek back to start */
  192.   if(!err)
  193.     err = xadHookAccess(XADAC_INPUTSEEK, u-ai->xai_InPos, 0, ai);
  194.  
  195.   return err;
  196. }
  197.  
  198. ASM(void) xMash_Free(REG(a0, struct xadArchiveInfo *ai),
  199. REG(a6, struct xadMasterBase *xadMasterBase))
  200. {
  201.   struct ExecBase * SysBase = xadMasterBase->xmb_SysBase;
  202.   if(ai->xai_DiskInfo)
  203.   {
  204.     struct xadTextInfo *ti, *ti2;
  205.     
  206.     for(ti = ai->xai_DiskInfo->xdi_TextInfo; ti; ti = ti2)
  207.     {
  208.       ti2 = ti->xti_Next;
  209.       if(ti->xti_Text)
  210.         FreeVec(ti->xti_Text);
  211.       xadFreeObjectA(ti, 0);
  212.     }
  213.     xadFreeObjectA(ai->xai_DiskInfo, 0);
  214.     ai->xai_DiskInfo = 0; /* clear the entry */
  215.   }
  216. }
  217.  
  218. struct xadClient xMash_Client = {
  219. NEXTCLIENT, XADCLIENT_VERSION, 1, XMASH_VERSION, XMASH_REVISION, 3,
  220. XADCF_DISKARCHIVER, XADCID_XMASH, "xMash", (BOOL (*)()) xMash_RecogData,
  221. (LONG (*)()) xMash_GetInfo, (LONG (*)()) xMash_UnArchive,
  222. (void (*)()) xMash_Free};
  223.  
  224. #endif /* XADASTER_XMASH_C */
  225.